#include "backend_service.h"
#include "../database/database_manager.h"
#include "../database/file_system_status.h"
#include "../command/command_executor.h"
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QJsonObject>
#include <QJsonDocument>
#include <QJsonArray>
#include <QDebug>
#include <QUrl>
#include <QUrlQuery>
#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QStandardPaths>
#include <QDesktopServices>
#include <QDateTime>
#include <QFileDialog>
#include <QUuid>
#include <QCryptographicHash>
#include <QQmlApplicationEngine>
#include <QQuickWindow>

BackendService::BackendService(QObject *parent)
    : QObject(parent)
    , m_networkManager(new QNetworkAccessManager(this))
    , m_baseUrl("http://localhost:8888") // 默认API地址，可以根据需要修改
    , m_databaseManager(nullptr)
    , m_qmlEngine(nullptr)
    , m_currentWindow(nullptr)
    , m_isFirstWindow(true)
    , m_commandExecutor(nullptr)
{
    // 连接网络请求完成信号 - 使用lambda表达式直接传递reply
    // 注意：login 和 exchangeAccessToken 请求现在由相应的 Command 类处理
    connect(m_networkManager, &QNetworkAccessManager::finished,
            this, [this](QNetworkReply *reply) {
                qDebug() << "网络请求完成，reply对象:" << reply;
                if (reply) {
                    // 所有请求现在由相应的 Command 类处理
                    reply->deleteLater();
                }
            });
    
    // 尝试从设置文件加载服务器地址
    loadServerHost();
}

BackendService::~BackendService()
{
}

void BackendService::setDatabaseManager(DatabaseManager *databaseManager)
{
    m_databaseManager = databaseManager;
}

DatabaseManager* BackendService::getDatabaseManager() const
{
    return m_databaseManager;
}

void BackendService::setCommandExecutor(CommandExecutor *commandExecutor)
{
    m_commandExecutor = commandExecutor;
}

CommandExecutor* BackendService::getCommandExecutor() const
{
    return m_commandExecutor;
}

void BackendService::setQmlEngine(QQmlApplicationEngine *engine)
{
    if (m_qmlEngine == engine) {
        // 如果已经设置过相同的引擎，直接返回
        return;
    }
    
    m_qmlEngine = engine;
    
    if (m_qmlEngine) {
        // 连接窗口创建完成信号，在窗口创建后更新引用
        QObject::connect(m_qmlEngine, &QQmlApplicationEngine::objectCreated,
                         [this](QObject *object, const QUrl &url) {
            QQuickWindow *window = qobject_cast<QQuickWindow *>(object);
            if (window) {
                // 从 URL 判断是哪个页面
                QString urlString = url.toString();
                QString pageName;
                if (urlString.contains("Login")) {
                    pageName = "Login";
                } else if (urlString.contains("Main")) {
                    pageName = "Main";
                }
                
                // 更新窗口引用
                if (!m_currentWindow || m_currentWindow != window) {
                    m_currentWindow = window;
                    if (!pageName.isEmpty()) {
                        m_currentPage = pageName;
                    }
                    qDebug() << "新窗口已创建，页面:" << (pageName.isEmpty() ? m_currentPage : pageName) << "URL:" << urlString;
                    
                    // 如果是 Main 窗口，执行同步网盘
                    if (pageName == "Main" && m_commandExecutor) {
                        qDebug() << "Main 窗口已创建，通过 CommandExecutor 执行同步网盘";
                        m_commandExecutor->executeSyncDisks();
                    }
                }
                
                // 连接窗口关闭事件，清除引用
                QObject::connect(window, &QQuickWindow::destroyed, [this, window]() {
                    if (m_currentWindow == window) {
                        m_currentWindow = nullptr;
                        m_currentPage.clear();
                        qDebug() << "窗口已关闭，清除引用";
                    }
                });
            }
        });
    }
}

// 从 rootObjects 中查找匹配的窗口
QQuickWindow* BackendService::findWindowByPageName(const QString &pageName)
{
    if (!m_qmlEngine) {
        return nullptr;
    }
    
    QObjectList rootObjects = m_qmlEngine->rootObjects();
    for (QObject *obj : rootObjects) {
        QQuickWindow *window = qobject_cast<QQuickWindow *>(obj);
        if (window) {
            QString title = window->title();
            // 根据页面名称匹配窗口的 title
            if (pageName == "Login" && title.contains("Login")) {
                return window;
            } else if (pageName == "Main" && title.contains("Main")) {
                return window;
            }
        }
    }
    return nullptr;
}

QQuickWindow* BackendService::getOrCreateWindow(const QString &windowTitle)
{
    if (!m_qmlEngine) {
        qDebug() << "QML 引擎未设置，无法创建窗口";
        return nullptr;
    }
    
    // 通过查询 rootObjects 查找匹配的窗口
    QQuickWindow* existingWindow = findWindowByPageName(windowTitle);
    if (existingWindow) {
        qDebug() << "窗口已存在且是同一个页面，直接返回:" << windowTitle;
        
        // 如果是 Main 窗口，执行同步网盘
        if (windowTitle == "Main" && m_commandExecutor) {
            qDebug() << "Main 窗口已显示，通过 CommandExecutor 执行同步网盘";
            m_commandExecutor->executeSyncDisks();
        }
        
        return existingWindow;
    }
       
    // 加载新页面
    qDebug() << "加载新页面:" << windowTitle;
    m_qmlEngine->loadFromModule("desktop", windowTitle);

    // 新窗口，返回 nullptr
    qDebug() << "新窗口，页面:" << windowTitle;
    return nullptr;
}

// loginCheckin 方法已迁移到 LoginCheckinCommand
// createUserWorkDirectory 方法已迁移到 LoginCheckinCommand
// 相关处理逻辑已移除

bool BackendService::loadAutoLogin()
{
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法读取自动登录状态";
        return false;
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 检查文件是否存在
    if (!QFile::exists(settingsPath)) {
        qDebug() << "设置文件不存在:" << settingsPath;
        return false;
    }
    
    // 读取设置
    QSettings settings(settingsPath, QSettings::IniFormat);
    bool autoLogin = settings.value("Login/AutoLogin", false).toBool();
    
    qDebug() << "从设置文件读取自动登录状态:" << autoLogin;
    return autoLogin;
}

void BackendService::saveAutoLogin(bool autoLogin)
{
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法保存自动登录状态";
        return;
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 确保目录存在
    QDir dir;
    QString settingsDir = QFileInfo(settingsPath).absolutePath();
    if (!dir.exists(settingsDir)) {
        if (!dir.mkpath(settingsDir)) {
            qDebug() << "无法创建设置目录:" << settingsDir;
            return;
        }
    }
    
    // 保存设置
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Login/AutoLogin", autoLogin);
    
    qDebug() << "自动登录状态已保存到:" << settingsPath;
    qDebug() << "自动登录状态:" << autoLogin;
}


void BackendService::saveToken(const QString &checkInToken)
{
    m_checkInToken = checkInToken;
    
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法保存checkInToken";
        return;
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 确保目录存在
    QDir dir;
    QString settingsDir = QFileInfo(settingsPath).absolutePath();
    if (!dir.exists(settingsDir)) {
        if (!dir.mkpath(settingsDir)) {
            qDebug() << "无法创建设置目录:" << settingsDir;
            return;
        }
    }
    
    // 保存token到设置文件
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Auth/CheckInToken", checkInToken);
    
    qDebug() << "Token已保存到:" << settingsPath;
    qDebug() << "Token值:" << checkInToken;
}

QString BackendService::loadCheckInToken()
{
    // 如果内存中已有checkInToken，直接返回
    if (!m_checkInToken.isEmpty()) {
        return m_checkInToken;
    }
    
    // 从设置文件加载checkInToken
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法加载checkInToken";
        return QString();
    }
    
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    if (!QFile::exists(settingsPath)) {
        qDebug() << "设置文件不存在:" << settingsPath;
        return QString();
    }
    
    QSettings settings(settingsPath, QSettings::IniFormat);
    QString checkInToken = settings.value("Auth/CheckInToken", "").toString();
    
    if (!checkInToken.isEmpty()) {
        m_checkInToken = checkInToken;
        qDebug() << "从设置文件加载checkInToken成功:" << checkInToken;
    } else {
        qDebug() << "设置文件中没有找到checkInToken";
    }
    
    return checkInToken;
}

void BackendService::clearToken()
{
    m_checkInToken.clear();
    
    // 从设置文件中删除token
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法清除token";
        return;
    }
    
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    if (QFile::exists(settingsPath)) {
        QSettings settings(settingsPath, QSettings::IniFormat);
        settings.remove("Auth/CheckInToken");
        qDebug() << "Token已从设置文件中清除";
    }
}

void BackendService::logout()
{
    // 将 accessToken 设置为空（通过 CommandExecutor）
    CommandExecutor::setAccessToken("");
    
    // 将 m_checkInToken 设置为空
    m_checkInToken.clear();
    
    // 将 setting.ini 中 checkInToken 设置为空
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法清除token";
        return;
    }
    
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 确保目录存在
    QDir dir;
    QString settingsDir = QFileInfo(settingsPath).absolutePath();
    if (!dir.exists(settingsDir)) {
        if (!dir.mkpath(settingsDir)) {
            qDebug() << "无法创建设置目录:" << settingsDir;
            return;
        }
    }
    
    // 将 checkInToken 设置为空字符串
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Auth/CheckInToken", "");
    settings.sync();
    
    qDebug() << "退出登录：已清除 accessToken 和 checkInToken";
}

void BackendService::addTokenToRequest(QNetworkRequest &request)
{
    // 如果有accessToken，直接使用
    QString accessToken = CommandExecutor::getAccessToken();
    if (!accessToken.isEmpty()) {
        request.setRawHeader("accessToken", accessToken.toUtf8());
        qDebug() << "已添加accessToken到请求头:" << accessToken;
    } else {
        qDebug() << "没有可用的accessToken，跳过添加请求头";
    }
}


void BackendService::saveDomains(const QJsonArray &domains)
{
    m_domains = domains;
    
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法保存domains";
        return;
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 确保目录存在
    QDir dir;
    QString settingsDir = QFileInfo(settingsPath).absolutePath();
    if (!dir.exists(settingsDir)) {
        if (!dir.mkpath(settingsDir)) {
            qDebug() << "无法创建设置目录:" << settingsDir;
            return;
        }
    }
    
    // 将domains转换为JSON字符串保存
    QJsonDocument doc(domains);
    QString domainsJson = doc.toJson(QJsonDocument::Compact);
    
    // 保存domains到设置文件
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Auth/Domains", domainsJson);
    
    qDebug() << "Domains已保存到:" << settingsPath;
    qDebug() << "Domains数量:" << domains.size();
    qDebug() << "Domains JSON:" << domainsJson;
    
    // 在保存domains后设置默认公司
    qDebug() << "保存domains后，检查并设置默认公司";
    setDefaultCompany();
}

QJsonArray BackendService::loadDomains()
{
    // 如果内存中已有domains，直接返回
    if (!m_domains.isEmpty()) {
        return m_domains;
    }
    
    // 从设置文件加载domains
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法加载domains";
        return QJsonArray();
    }
    
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    if (!QFile::exists(settingsPath)) {
        qDebug() << "设置文件不存在:" << settingsPath;
        return QJsonArray();
    }
    
    QSettings settings(settingsPath, QSettings::IniFormat);
    QString domainsJson = settings.value("Auth/Domains", "").toString();
    
    if (!domainsJson.isEmpty()) {
        // 解析JSON字符串
        QJsonParseError parseError;
        QJsonDocument doc = QJsonDocument::fromJson(domainsJson.toUtf8(), &parseError);
        
        if (parseError.error == QJsonParseError::NoError && doc.isArray()) {
            m_domains = doc.array();
            qDebug() << "从设置文件加载domains成功，数量:" << m_domains.size();
            qDebug() << "Domains JSON:" << domainsJson;
        } else {
            qDebug() << "解析domains JSON失败:" << parseError.errorString();
        }
    } else {
        qDebug() << "设置文件中没有找到domains";
    }
    
    return m_domains;
}

void BackendService::clearDomains()
{
    m_domains = QJsonArray();
    
    // 从设置文件中删除domains
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法清除domains";
        return;
    }
    
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    if (QFile::exists(settingsPath)) {
        QSettings settings(settingsPath, QSettings::IniFormat);
        settings.remove("Auth/Domains");
        qDebug() << "Domains已从设置文件中清除";
    }
}

QVariantList BackendService::getDomains()
{
    QJsonArray domains = loadDomains();
    QVariantList result;
    
    for (const QJsonValue &value : domains) {
        if (value.isObject()) {
            QJsonObject domain = value.toObject();
            QVariantMap domainMap;
            domainMap["id"] = domain["id"].toString();
            domainMap["name"] = domain["name"].toString();
            domainMap["weixinCorpId"] = domain["weixinCorpId"].toString();
            domainMap["islog"] = domain["islog"].toBool();
            domainMap["logoUrl"] = domain["logoUrl"].toString();
            domainMap["status"] = domain["status"].toInt();
            result.append(domainMap);
        }
    }
    
    qDebug() << "获取domains信息，数量:" << result.size();
    return result;
}

QString BackendService::getAccessToken()
{
    // 从 CommandExecutor 获取访问令牌
    return CommandExecutor::getAccessToken();
}

void BackendService::setAccessToken(const QString &accessToken)
{
    // 通过 CommandExecutor 设置访问令牌
    CommandExecutor::setAccessToken(accessToken);
}

bool BackendService::isLoggedIn() const
{
    return !CommandExecutor::getAccessToken().isEmpty();
}

void BackendService::saveSelectedCompany(const QString &companyId, const QString &companyName)
{
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法保存选中的公司";
        return;
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 确保目录存在
    QDir dir;
    QString settingsDir = QFileInfo(settingsPath).absolutePath();
    if (!dir.exists(settingsDir)) {
        if (!dir.mkpath(settingsDir)) {
            qDebug() << "无法创建设置目录:" << settingsDir;
            return;
        }
    }
    
    // 保存选中的公司ID到设置文件（只保存ID，名称从domains中获取）
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Selection/SelectedCompanyId", companyId);
    settings.sync();
    
    qDebug() << "已保存选中的公司ID到设置文件:" << companyId;
}

QStringList BackendService::loadSelectedCompany()
{
    QStringList result;
    
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法加载选中的公司";
        return result;
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    if (!QFile::exists(settingsPath)) {
        qDebug() << "设置文件不存在，无法加载选中的公司";
        return result;
    }
    
    // 从设置文件加载选中的公司
    QSettings settings(settingsPath, QSettings::IniFormat);
    QString companyId = settings.value("Company/SelectedId", "").toString();
    QString companyName = settings.value("Company/SelectedName", "").toString();
    
    if (!companyId.isEmpty() && !companyName.isEmpty()) {
        result << companyId << companyName;
        qDebug() << "已加载选中的公司:" << companyName << "ID:" << companyId;
    } else {
        qDebug() << "没有找到保存的选中公司信息";
    }
    
    return result;
}


void BackendService::saveSelectedCompanyId(const QString &companyId)
{
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法保存选中的公司ID";
        return;
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Selection/SelectedCompanyId", companyId);
    qDebug() << "已保存选中的公司ID:" << companyId;
}

QString BackendService::loadSelectedCompanyId()
{
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法加载选中的公司ID";
        return "";
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    QSettings settings(settingsPath, QSettings::IniFormat);
    QString companyId = settings.value("Selection/SelectedCompanyId", "").toString();
    qDebug() << "已加载选中的公司ID:" << companyId;
    return companyId;
}

void BackendService::saveSelectedDiskId(const QString &diskId)
{
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Selection/SelectedDiskId", diskId);
    qDebug() << "已保存选中的网盘ID:" << diskId;
}

QString BackendService::loadSelectedDiskId()
{
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    QSettings settings(settingsPath, QSettings::IniFormat);
    QString diskId = settings.value("Selection/SelectedDiskId", "").toString();
    qDebug() << "已加载选中的网盘ID:" << diskId;
    return diskId;
}

bool BackendService::testServerHost(const QString &serverHost)
{
    if (serverHost.isEmpty()) {
        qDebug() << "服务器地址为空";
        return false;
    }
    
    // 验证URL格式
    QUrl url(serverHost);
    if (!url.isValid() || url.scheme().isEmpty() || url.host().isEmpty()) {
        qDebug() << "服务器地址格式无效:" << serverHost;
        return false;
    }
    
    // 检查scheme是否为http或https
    QString scheme = url.scheme().toLower();
    if (scheme != "http" && scheme != "https") {
        qDebug() << "不支持的协议:" << scheme;
        return false;
    }
    
    qDebug() << "服务器地址格式验证通过:" << serverHost;
    return true;
}

void BackendService::saveServerHost(const QString &serverHost)
{
    if (serverHost.isEmpty()) {
        qDebug() << "服务器地址为空，无法保存";
        return;
    }
    
    // 验证服务器地址格式
    if (!testServerHost(serverHost)) {
        qDebug() << "服务器地址格式无效，无法保存:" << serverHost;
        return;
    }
    
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法保存服务器地址";
        return;
    }
    
    // 确保目录存在
    QDir homeDir(homePath);
    if (!homeDir.exists(".myapps")) {
        homeDir.mkpath(".myapps");
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 保存服务器地址
    QSettings settings(settingsPath, QSettings::IniFormat);
    settings.setValue("Server/Host", serverHost);
    settings.sync();
    
    // 更新当前使用的baseUrl
    m_baseUrl = serverHost;
    
    qDebug() << "服务器地址已保存到:" << settingsPath;
    qDebug() << "服务器地址:" << serverHost;
    qDebug() << "m_baseUrl已更新为:" << m_baseUrl;
}

QString BackendService::loadServerHost()
{
    // 获取用户主目录
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "无法获取用户主目录，无法读取服务器地址";
        return "";
    }
    
    // 构建设置文件路径
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    
    // 检查文件是否存在
    if (!QFile::exists(settingsPath)) {
        qDebug() << "设置文件不存在，使用默认服务器地址";
        return "";
    }
    
    // 读取服务器地址
    QSettings settings(settingsPath, QSettings::IniFormat);
    QString serverHost = settings.value("Server/Host", "").toString();
    
    if (!serverHost.isEmpty()) {
        // 验证加载的服务器地址格式
        if (testServerHost(serverHost)) {
            // 更新当前使用的baseUrl
            m_baseUrl = serverHost;
            qDebug() << "已加载服务器地址:" << serverHost;
            qDebug() << "m_baseUrl已更新为:" << m_baseUrl;
        } else {
            qDebug() << "加载的服务器地址格式无效:" << serverHost;
            serverHost = "";
        }
    } else {
        qDebug() << "未找到保存的服务器地址，使用默认值";
    }
    
    return serverHost;
}

void BackendService::setDefaultCompany()
{
    // 检查是否有保存的公司ID
    QString savedCompanyId = loadSelectedCompanyId();
    bool needSetDefault = false;
    
    if (savedCompanyId.isEmpty()) {
        qDebug() << "没有保存的公司ID，需要设置默认公司";
        needSetDefault = true;
    } else {
        // 检查保存的公司ID是否在domains中
        bool found = false;
        
        for (const QJsonValue &value : m_domains) {
            if (value.isObject()) {
                QJsonObject domain = value.toObject();
                QString domainId = domain["id"].toString();
                if (domainId == savedCompanyId) {
                    found = true;
                    qDebug() << "保存的公司ID在domains中找到:" << savedCompanyId;
                    break;
                }
            }
        }
        
        if (!found) {
            qDebug() << "保存的公司ID不在domains中，需要设置默认公司";
            needSetDefault = true;
        }
    }
    
    if (needSetDefault && !m_domains.isEmpty()) {
        // 设置domains中第一个为公司为默认
        QJsonValue firstDomain = m_domains.first();
        if (firstDomain.isObject()) {
            QJsonObject domain = firstDomain.toObject();
            QString defaultCompanyId = domain["id"].toString();
            QString defaultCompanyName = domain["name"].toString();
            
            // 保存为默认公司
            saveSelectedCompanyId(defaultCompanyId);
            
            qDebug() << "已设置默认公司:" << defaultCompanyName << "ID:" << defaultCompanyId;
        }
    }
}

void BackendService::tryAutoLogin()
{
    // 如果已经登录，跳过自动登录检查
    if (isLoggedIn()) {
        qDebug() << "应用启动时已登录，跳过自动登录检查";
        return;
    }
    
    // 检查 AutoLogin 设置
    bool autoLogin = loadAutoLogin();
    if (!autoLogin) {
        qDebug() << "AutoLogin=false 或未设置，不执行自动登录";
        return;
    }
    
    qDebug() << "检测到 AutoLogin=true，开始执行自动登录";
    
    // 检查是否有 checkInToken
    QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    if (homePath.isEmpty()) {
        qDebug() << "自动登录失败：无法获取用户主目录";
        return;
    }
    
    QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
    if (!QFile::exists(settingsPath)) {
        qDebug() << "自动登录失败：设置文件不存在";
        return;
    }
    
    QSettings settings(settingsPath, QSettings::IniFormat);
    QString checkInToken = settings.value("Auth/CheckInToken", "").toString();
    
    if (checkInToken.isEmpty()) {
        qDebug() << "自动登录失败：没有可用的checkInToken";
        return;
    }
    
    // 加载 domains
    QJsonArray domains = loadDomains();
    if (domains.isEmpty()) {
        qDebug() << "自动登录失败：没有可用的domains信息";
        return;
    }
    
    // 设置默认公司（如果需要）
    setDefaultCompany();
    
    // 获取选中的公司ID
    QString domainId = loadSelectedCompanyId();
    if (domainId.isEmpty() && !domains.isEmpty()) {
        // 如果没有选中的公司，使用第一个
        QJsonValue firstDomain = domains.first();
        if (firstDomain.isObject()) {
            QJsonObject domain = firstDomain.toObject();
            domainId = domain["id"].toString();
            saveSelectedCompanyId(domainId);
            qDebug() << "自动登录：使用第一个公司作为默认公司，ID:" << domainId;
        }
    }
    
    if (domainId.isEmpty()) {
        qDebug() << "自动登录失败：无法获取公司ID";
        return;
    }
    
    // 执行自动登录（通过 ExchangeAccessTokenCommand）
    if (!m_commandExecutor) {
        qDebug() << "自动登录失败：CommandExecutor 未设置";
        return;
    }
    
    qDebug() << "自动登录：开始执行 ExchangeAccessToken";
    m_commandExecutor->executeExchangeAccessToken();
}

// exchangeAccessToken 方法已迁移到 ExchangeAccessTokenCommand
// 相关处理逻辑已移除


void BackendService::selectAndAddFile(const QString &folderId)
{
    if (!m_databaseManager) {
        qDebug() << "数据库管理器未设置，无法上传文件";
        return;
    }
    
    // 打开文件选择对话框
    QString fileName = QFileDialog::getOpenFileName(
        nullptr,
        "选择要上传的文件",
        QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation),
        "所有文件 (*.*)"
    );
    
    if (fileName.isEmpty()) {
        qDebug() << "用户取消了文件选择";
        return;
    }
    
    qDebug() << "选择文件:" << fileName;
    
    // 查询文件夹信息以获取 diskId
    KmsFolder folder = m_databaseManager->queryFolderById(folderId);
    if (folder.id.isEmpty()) {
        qDebug() << "未找到文件夹，文件夹ID:" << folderId;
        return;
    }
    
    QString diskId = folder.diskId;
    if (diskId.isEmpty()) {
        qDebug() << "文件夹没有关联的网盘ID";
        return;
    }
    
    qDebug() << "文件夹信息 - 名称:" << folder.name << "网盘ID:" << diskId;
    
    // 获取文件信息
    QFileInfo fileInfo(fileName);
    if (!fileInfo.exists()) {
        qDebug() << "文件不存在:" << fileName;
        return;
    }
    
    QString sourceFileName = fileInfo.fileName();
    qint64 fileSize = fileInfo.size();
    
    // 获取工作目录
    QString workBaseDir = getUserWorkBaseDir();
    if (workBaseDir.isEmpty()) {
        qDebug() << "用户工作目录未设置";
        return;
    }
    
    // 构建目标文件路径（相对于工作目录）
    // 使用文件夹路径作为基础路径，规范化路径分隔符
    QString normalizedFolderPath = folder.path;
    normalizedFolderPath.replace("\\", "/");
    if (normalizedFolderPath.startsWith("/")) {
        normalizedFolderPath = normalizedFolderPath.mid(1); // 移除开头的斜杠
    }
    
    QString relativePath = normalizedFolderPath.isEmpty() ? sourceFileName : (normalizedFolderPath + "/" + sourceFileName);
    QString targetDir = normalizedFolderPath.isEmpty() ? workBaseDir : (workBaseDir + "/" + normalizedFolderPath);
    QString targetFilePath = workBaseDir + "/" + relativePath;
    
    // 确保目标目录存在
    QDir targetDirObj(targetDir);
    if (!targetDirObj.exists()) {
        if (!targetDirObj.mkpath(".")) {
            qDebug() << "无法创建目标目录:" << targetDir;
            return;
        }
    }
    
    // 检查目标文件是否已存在
    if (QFile::exists(targetFilePath)) {
        qDebug() << "目标文件已存在，询问用户是否覆盖:" << targetFilePath;
        // 发送信号询问用户是否覆盖
        emit askFileOverwrite(fileName, targetFilePath, sourceFileName);
        return;
    }
    
    // 目标文件不存在，直接执行复制
    // 复制文件到工作目录
    QFile sourceFile(fileName);
    if (!sourceFile.copy(targetFilePath)) {
        qDebug() << "复制文件失败:" << sourceFile.errorString();
        return;
    }
    
    qDebug() << "文件已复制到:" << targetFilePath;
}

void BackendService::handleFileOverwriteConfirm(bool overwrite, const QString &sourceFilePath, 
                                                const QString &targetFilePath, const QString &folderId)
{
    if (!overwrite) {
        qDebug() << "用户选择不覆盖文件，取消上传";
        return;
    }
    
    qDebug() << "用户选择覆盖文件，开始复制和上传";
    
    if (!m_databaseManager) {
        qDebug() << "数据库管理器未设置";
        return;
    }
    
    // 查询文件夹信息以获取 diskId
    KmsFolder folder = m_databaseManager->queryFolderById(folderId);
    if (folder.id.isEmpty()) {
        qDebug() << "未找到文件夹，文件夹ID:" << folderId;
        return;
    }
    
    QString diskId = folder.diskId;
    if (diskId.isEmpty()) {
        qDebug() << "文件夹没有关联的网盘ID";
        return;
    }
    
    // 获取文件信息
    QFileInfo fileInfo(sourceFilePath);
    if (!fileInfo.exists()) {
        qDebug() << "源文件不存在:" << sourceFilePath;
        return;
    }
    
    QString sourceFileName = fileInfo.fileName();
    qint64 fileSize = fileInfo.size();
    
    // 获取工作目录
    QString workBaseDir = getUserWorkBaseDir();
    if (workBaseDir.isEmpty()) {
        qDebug() << "用户工作目录未设置";
        return;
    }
    
    // 构建相对路径
    QString normalizedFolderPath = folder.path;
    normalizedFolderPath.replace("\\", "/");
    if (normalizedFolderPath.startsWith("/")) {
        normalizedFolderPath = normalizedFolderPath.mid(1);
    }
    
    QString relativePath = normalizedFolderPath.isEmpty() ? sourceFileName : (normalizedFolderPath + "/" + sourceFileName);
    
    // 删除已存在的目标文件
    if (QFile::exists(targetFilePath)) {
        if (!QFile::remove(targetFilePath)) {
            qDebug() << "无法删除已存在的目标文件:" << targetFilePath;
            return;
        }
        qDebug() << "已删除已存在的目标文件:" << targetFilePath;
    }
    
    // 执行复制
    QFile sourceFile(sourceFilePath);
    if (!sourceFile.copy(targetFilePath)) {
        qDebug() << "复制文件失败:" << sourceFile.errorString();
        return;
    }
    
    qDebug() << "文件已复制到:" << targetFilePath;
}



void BackendService::openFile(const QString &filePath)
{
    qDebug() << "准备打开文件:" << filePath;
    
    // 检查文件是否存在
    QFileInfo fileInfo(filePath);
    if (!fileInfo.exists()) {
        qDebug() << "文件不存在:" << filePath;
        emit openFileCompleted(-1, "文件不存在: " + filePath);
        return;
    }
    
    if (!fileInfo.isFile()) {
        qDebug() << "路径不是文件:" << filePath;
        emit openFileCompleted(-2, "路径不是文件: " + filePath);
        return;
    }
    
    // 使用 QDesktopServices 打开文件
    QUrl fileUrl = QUrl::fromLocalFile(filePath);
    bool success = QDesktopServices::openUrl(fileUrl);
    
    if (success) {
        qDebug() << "成功打开文件:" << filePath;
        emit openFileCompleted(0, "文件打开成功");
    } else {
        qDebug() << "打开文件失败:" << filePath;
        emit openFileCompleted(-3, "无法打开文件，可能没有关联的应用程序");
    }
}

QString BackendService::getUserWorkBaseDir() const
{
    // Home/.myapps/{username}/work
    const QString homeDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    return QDir::cleanPath(homeDir + "/.myapps/" + m_currentUsername + "/work");
}



void BackendService::handleNetworkError(QNetworkReply *reply)
{
    int errorCode = reply->error();
    QString errorString = reply->errorString();
    
    qDebug() << "BackendService: 网络错误 - 代码:" << errorCode << "描述:" << errorString;
    
    // 发送网络错误信号
    emit networkError(errorCode, errorString);
}

QNetworkRequest BackendService::createRequest(const QString &url, const QString &method)
{
    QNetworkRequest request;
    QUrl requestUrl(url);
    QString upperMethod = method.toUpper();
    
    // 由于服务端采用 HiddenHttpMethodFilter 隐藏提交方法
    // 对于非 GET、POST 的方法，统一使用 POST 并在 URL 后添加 _method 参数
    if (upperMethod == "PUT" || upperMethod == "DELETE" || upperMethod == "PATCH") {
        // 使用 POST 方法
        request.setAttribute(QNetworkRequest::CustomVerbAttribute, "POST");
        
        // 在 URL 后添加 _method 参数
        QUrlQuery query(requestUrl.query());
        query.addQueryItem("_method", upperMethod);
        requestUrl.setQuery(query);
    } else if (upperMethod == "POST") {
        request.setAttribute(QNetworkRequest::CustomVerbAttribute, "POST");
    }
    // GET 方法不需要特殊设置，使用默认的 GET
    
    request.setUrl(requestUrl);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
    request.setRawHeader("Accept", "application/json");
    request.setRawHeader("User-Agent", "BackendService/1.0");
    
    return request;
}
